package graphesTOTEST;
/**
 * Classe Ensemble
 *
 * Cette classe permet de manipuler un ensemble d'entiers.
 * Plusieurs procédures permettent de rajouter, d'enlever, d'obtenir un
 * élément ou bien de retourner le nombre d'éléments d'un ensemble.
 */
public class Ensemble { 
	
	private int [] T;   //Tableau contenant les entiers de l'ensemble
	private int indice; //Indice de remplissage (le remplissage de 
						// T va de l'indice 0 à indice)

	/**
 	 * Constructeur par défaut de la classe Ensemble.
 	 */ 
	public Ensemble() {
		indice = -1;
 		T      = new int [10000]; //Par défaut 10000 éléments
 	} 

 	/**
 	 * Constructeur par paramètre.
 	 */ 
	public Ensemble(int nbElemenMax) {
		indice = -1;
 		T      = new int [nbElemenMax];
 	} 


	/**
 	 * Constructeur par clonage
 	 */ 
	public Ensemble(Ensemble e) {
		indice = e.indice;
 		T      = new int [e.T.length];
 		//RECOPIE DU CONTENU DE L'ENSEMBLE e
 		for (int i=0; i<=indice; i++) { // <=
	 		T[i] = e.T[i];
 		}
 	}

	/**
 	 * Retourne vrai si l'ensemble est vide et faux sinon. .
 	 *
 	 * @param aucun
 	 * @return boolean
 	 */ 
	public boolean estVide() {
		return (indice<0);
	} 

	/**
 	 * Retourne vrai si l'ensemble est plein et faux sinon.
 	 *
 	 * @param aucun
 	 * @return boolean
 	 */ 
	public boolean estPlein() {
		return (indice>=(T.length-1)); // >=
	}

	/**
 	 * Retourne le nombre d'éléments de l'ensemble.
 	 *
 	 * @param aucun
 	 * @return int
 	 */	 
	public int nbElement() {
		return (indice+1); 
	} 


	/**
 	 * Retourne un élément de l'ensemble.
 	 *
 	 * @param aucun
 	 * @return int
 	 */ 
	public int element() {
		if (estVide()) {
			System.out.println("Ensemble::element(): Erreur, l'ensemble est vide");
			System.exit(-1);
		}
		return T[0];
	}

	/**
 	 * La méthode appartient retourne vrai si l'entier passé en paramètre est 
 	 * dans l'ensemble et faux sinon.
 	 *
 	 * @param int element : entier dont on souhaite savoir s'il appartient à 
 	 * l'ensemble
 	 * @return boolean
 	 */ 
	public boolean appartient (int element) {
		int i=0;
 		boolean trouve=false;
 		while(!trouve && i<nbElement()) {
	 		if(T[i] == element){
		 		trouve = true;
		 	}
  			i++;
 		}
	 	return trouve;
	 }

	/**
 	 * Retourne l'indice d'un élement s'il est 
 	 * présent dans le tableau T et -1 sinon.
 	 *
 	 * @param int element : entier dont on souhaite connaitre l'indice.
 	 * @return boolean
 	 */ 
	public int getIndice(int element) {
		int i   = 0;
 		int ind = -1;
 		while( (ind == -1) && (i < nbElement())) {
	 		if(T[i] == element){
		 		ind = i;
		 	}
  			i++;
 		}
	 	return ind;
	 }
	 

	/**
 	 * La méthode ajoutelt permet d'ajouter un élément dans l'ensemble. 
 	 *
 	 * @param int element : entier à ajouter
 	 * @return aucun
 	 */ 
	public void ajoutElt(int element) {
		if(estPlein()) {
			System.out.println("Ensemble::ajoutelt(): Erreur l'ensemble est plein"); 
  			System.exit(-1);
 		}
 		//ON AJOUTE UNIQUEMENT SI L'ELEMENT N'EST PAS DEJA PRESENT (PROPRIETE D'UN ENSEMBLE...)
 		if (!appartient(element)) {
 			indice++;
 			T[indice] = element;
		}
	}


	/**
 	 * Procédure permettant d'ôter un élément présent dans un ensemble.
 	 *
 	 * @param int
 	 * @return aucun
 	 */ 
	public void oterElt(int element) {
		int ind = getIndice(element);
		if (ind != -1) {
			//ON PREND LE DERNIER ELEMENT DE T (T[indice]) ET ON LE PLACE A 
			//L'INDICE indice (cad à la place de element)
			T[ind] = T[indice];
			indice --; //Réduction de la taille de l'ensemble ...
		}
	}

	public String toString() {
    	String result="{";
    	for(int i=0; i<nbElement()-1; i++) {
    		result += " " + T[i]+" ,";
		}
		if (!estVide()) {
			result += " " + T[nbElement()-1] + " ";
		}
    	result += "}";
    	return result;
  	}

	
	public boolean egal(Ensemble ens) {
		
		if (nbElement() != ens.nbElement())
		  return false;
		else {
		  //TEST DE L'APPARTENANCE DE CHAQUE ELEMENT DE L'ENSEMBLE COURANT 
		  //  A L'ENSEMBLE ens
		  int i=0;
		  boolean prop = true;
 		  while (prop && (i<=indice)) {  // <=
	 	  	prop = ens.appartient(T[i]); //Test l'appartenace de T[i] � ens
	 	  	i++;
 		  }
		  return prop;
	    }
    }
	

} //Fin de Ensemble